home *** CD-ROM | disk | FTP | other *** search
/ Personal Computer World 2009 February / PCWFEB09.iso / Software / Linux / Kubuntu 8.10 / kubuntu-8.10-desktop-i386.iso / casper / filesystem.squashfs / usr / lib / python2.5 / filecmp.pyc (.txt) < prev    next >
Python Compiled Bytecode  |  2008-10-29  |  10KB  |  319 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.5)
  3.  
  4. '''Utilities for comparing files and directories.
  5.  
  6. Classes:
  7.     dircmp
  8.  
  9. Functions:
  10.     cmp(f1, f2, shallow=1) -> int
  11.     cmpfiles(a, b, common) -> ([], [], [])
  12.  
  13. '''
  14. import os
  15. import stat
  16. import warnings
  17. from itertools import ifilter, ifilterfalse, imap, izip
  18. __all__ = [
  19.     'cmp',
  20.     'dircmp',
  21.     'cmpfiles']
  22. _cache = { }
  23. BUFSIZE = 8192
  24.  
  25. def cmp(f1, f2, shallow = 1):
  26.     '''Compare two files.
  27.  
  28.     Arguments:
  29.  
  30.     f1 -- First file name
  31.  
  32.     f2 -- Second file name
  33.  
  34.     shallow -- Just check stat signature (do not read the files).
  35.                defaults to 1.
  36.  
  37.     Return value:
  38.  
  39.     True if the files are the same, False otherwise.
  40.  
  41.     This function uses a cache for past comparisons and the results,
  42.     with a cache invalidation mechanism relying on stale signatures.
  43.  
  44.     '''
  45.     s1 = _sig(os.stat(f1))
  46.     s2 = _sig(os.stat(f2))
  47.     if s1[0] != stat.S_IFREG or s2[0] != stat.S_IFREG:
  48.         return False
  49.     
  50.     if shallow and s1 == s2:
  51.         return True
  52.     
  53.     if s1[1] != s2[1]:
  54.         return False
  55.     
  56.     result = _cache.get((f1, f2))
  57.     if result and (s1, s2) == result[:2]:
  58.         return result[2]
  59.     
  60.     outcome = _do_cmp(f1, f2)
  61.     _cache[(f1, f2)] = (s1, s2, outcome)
  62.     return outcome
  63.  
  64.  
  65. def _sig(st):
  66.     return (stat.S_IFMT(st.st_mode), st.st_size, st.st_mtime)
  67.  
  68.  
  69. def _do_cmp(f1, f2):
  70.     bufsize = BUFSIZE
  71.     fp1 = open(f1, 'rb')
  72.     fp2 = open(f2, 'rb')
  73.     while True:
  74.         b1 = fp1.read(bufsize)
  75.         b2 = fp2.read(bufsize)
  76.         if b1 != b2:
  77.             return False
  78.         
  79.         if not b1:
  80.             return True
  81.             continue
  82.  
  83.  
  84. class dircmp:
  85.     """A class that manages the comparison of 2 directories.
  86.  
  87.     dircmp(a,b,ignore=None,hide=None)
  88.       A and B are directories.
  89.       IGNORE is a list of names to ignore,
  90.         defaults to ['RCS', 'CVS', 'tags'].
  91.       HIDE is a list of names to hide,
  92.         defaults to [os.curdir, os.pardir].
  93.  
  94.     High level usage:
  95.       x = dircmp(dir1, dir2)
  96.       x.report() -> prints a report on the differences between dir1 and dir2
  97.        or
  98.       x.report_partial_closure() -> prints report on differences between dir1
  99.             and dir2, and reports on common immediate subdirectories.
  100.       x.report_full_closure() -> like report_partial_closure,
  101.             but fully recursive.
  102.  
  103.     Attributes:
  104.      left_list, right_list: The files in dir1 and dir2,
  105.         filtered by hide and ignore.
  106.      common: a list of names in both dir1 and dir2.
  107.      left_only, right_only: names only in dir1, dir2.
  108.      common_dirs: subdirectories in both dir1 and dir2.
  109.      common_files: files in both dir1 and dir2.
  110.      common_funny: names in both dir1 and dir2 where the type differs between
  111.         dir1 and dir2, or the name is not stat-able.
  112.      same_files: list of identical files.
  113.      diff_files: list of filenames which differ.
  114.      funny_files: list of files which could not be compared.
  115.      subdirs: a dictionary of dircmp objects, keyed by names in common_dirs.
  116.      """
  117.     
  118.     def __init__(self, a, b, ignore = None, hide = None):
  119.         self.left = a
  120.         self.right = b
  121.         if hide is None:
  122.             self.hide = [
  123.                 os.curdir,
  124.                 os.pardir]
  125.         else:
  126.             self.hide = hide
  127.         if ignore is None:
  128.             self.ignore = [
  129.                 'RCS',
  130.                 'CVS',
  131.                 'tags']
  132.         else:
  133.             self.ignore = ignore
  134.  
  135.     
  136.     def phase0(self):
  137.         self.left_list = _filter(os.listdir(self.left), self.hide + self.ignore)
  138.         self.right_list = _filter(os.listdir(self.right), self.hide + self.ignore)
  139.         self.left_list.sort()
  140.         self.right_list.sort()
  141.  
  142.     
  143.     def phase1(self):
  144.         a = dict(izip(imap(os.path.normcase, self.left_list), self.left_list))
  145.         b = dict(izip(imap(os.path.normcase, self.right_list), self.right_list))
  146.         self.common = map(a.__getitem__, ifilter(b.has_key, a))
  147.         self.left_only = map(a.__getitem__, ifilterfalse(b.has_key, a))
  148.         self.right_only = map(b.__getitem__, ifilterfalse(a.has_key, b))
  149.  
  150.     
  151.     def phase2(self):
  152.         self.common_dirs = []
  153.         self.common_files = []
  154.         self.common_funny = []
  155.         for x in self.common:
  156.             a_path = os.path.join(self.left, x)
  157.             b_path = os.path.join(self.right, x)
  158.             ok = 1
  159.             
  160.             try:
  161.                 a_stat = os.stat(a_path)
  162.             except os.error:
  163.                 why = None
  164.                 ok = 0
  165.  
  166.             
  167.             try:
  168.                 b_stat = os.stat(b_path)
  169.             except os.error:
  170.                 why = None
  171.                 ok = 0
  172.  
  173.             if ok:
  174.                 a_type = stat.S_IFMT(a_stat.st_mode)
  175.                 b_type = stat.S_IFMT(b_stat.st_mode)
  176.                 if a_type != b_type:
  177.                     self.common_funny.append(x)
  178.                 elif stat.S_ISDIR(a_type):
  179.                     self.common_dirs.append(x)
  180.                 elif stat.S_ISREG(a_type):
  181.                     self.common_files.append(x)
  182.                 else:
  183.                     self.common_funny.append(x)
  184.             a_type != b_type
  185.             self.common_funny.append(x)
  186.         
  187.  
  188.     
  189.     def phase3(self):
  190.         xx = cmpfiles(self.left, self.right, self.common_files)
  191.         (self.same_files, self.diff_files, self.funny_files) = xx
  192.  
  193.     
  194.     def phase4(self):
  195.         self.subdirs = { }
  196.         for x in self.common_dirs:
  197.             a_x = os.path.join(self.left, x)
  198.             b_x = os.path.join(self.right, x)
  199.             self.subdirs[x] = dircmp(a_x, b_x, self.ignore, self.hide)
  200.         
  201.  
  202.     
  203.     def phase4_closure(self):
  204.         self.phase4()
  205.         for sd in self.subdirs.itervalues():
  206.             sd.phase4_closure()
  207.         
  208.  
  209.     
  210.     def report(self):
  211.         print 'diff', self.left, self.right
  212.         if self.left_only:
  213.             self.left_only.sort()
  214.             print 'Only in', self.left, ':', self.left_only
  215.         
  216.         if self.right_only:
  217.             self.right_only.sort()
  218.             print 'Only in', self.right, ':', self.right_only
  219.         
  220.         if self.same_files:
  221.             self.same_files.sort()
  222.             print 'Identical files :', self.same_files
  223.         
  224.         if self.diff_files:
  225.             self.diff_files.sort()
  226.             print 'Differing files :', self.diff_files
  227.         
  228.         if self.funny_files:
  229.             self.funny_files.sort()
  230.             print 'Trouble with common files :', self.funny_files
  231.         
  232.         if self.common_dirs:
  233.             self.common_dirs.sort()
  234.             print 'Common subdirectories :', self.common_dirs
  235.         
  236.         if self.common_funny:
  237.             self.common_funny.sort()
  238.             print 'Common funny cases :', self.common_funny
  239.         
  240.  
  241.     
  242.     def report_partial_closure(self):
  243.         self.report()
  244.         for sd in self.subdirs.itervalues():
  245.             print 
  246.             sd.report()
  247.         
  248.  
  249.     
  250.     def report_full_closure(self):
  251.         self.report()
  252.         for sd in self.subdirs.itervalues():
  253.             print 
  254.             sd.report_full_closure()
  255.         
  256.  
  257.     methodmap = dict(subdirs = phase4, same_files = phase3, diff_files = phase3, funny_files = phase3, common_dirs = phase2, common_files = phase2, common_funny = phase2, common = phase1, left_only = phase1, right_only = phase1, left_list = phase0, right_list = phase0)
  258.     
  259.     def __getattr__(self, attr):
  260.         if attr not in self.methodmap:
  261.             raise AttributeError, attr
  262.         
  263.         self.methodmap[attr](self)
  264.         return getattr(self, attr)
  265.  
  266.  
  267.  
  268. def cmpfiles(a, b, common, shallow = 1):
  269.     """Compare common files in two directories.
  270.  
  271.     a, b -- directory names
  272.     common -- list of file names found in both directories
  273.     shallow -- if true, do comparison based solely on stat() information
  274.  
  275.     Returns a tuple of three lists:
  276.       files that compare equal
  277.       files that are different
  278.       filenames that aren't regular files.
  279.  
  280.     """
  281.     res = ([], [], [])
  282.     for x in common:
  283.         ax = os.path.join(a, x)
  284.         bx = os.path.join(b, x)
  285.         res[_cmp(ax, bx, shallow)].append(x)
  286.     
  287.     return res
  288.  
  289.  
  290. def _cmp(a, b, sh, abs = abs, cmp = cmp):
  291.     
  292.     try:
  293.         return not abs(cmp(a, b, sh))
  294.     except os.error:
  295.         return 2
  296.  
  297.  
  298.  
  299. def _filter(flist, skip):
  300.     return list(ifilterfalse(skip.__contains__, flist))
  301.  
  302.  
  303. def demo():
  304.     import sys as sys
  305.     import getopt as getopt
  306.     (options, args) = getopt.getopt(sys.argv[1:], 'r')
  307.     if len(args) != 2:
  308.         raise getopt.GetoptError('need exactly two args', None)
  309.     
  310.     dd = dircmp(args[0], args[1])
  311.     if ('-r', '') in options:
  312.         dd.report_full_closure()
  313.     else:
  314.         dd.report()
  315.  
  316. if __name__ == '__main__':
  317.     demo()
  318.  
  319.